package AbstractTests;

import static org.junit.Assert.assertTrue;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import Exceptions.PreCondException;
import Impl.Bloc;
import Impl.Terrain;
import Impl.Type;
import Services.BlocService;
import Services.TerrainService;

public abstract class AbstractTerrainServiceTest {
	// TODO refaire tous les objectif de test avec des boucles
	private TerrainService terrain;
	
	protected AbstractTerrainServiceTest() {
		terrain = null;
	}
	
	protected final TerrainService getTerrain() {
		return terrain;
	}
		
	protected final void setTerrain(TerrainService terrain) {
		this.terrain = terrain;
	}

	@Before
	public abstract void beforeTests(); 

	@After
	public final void afterTests() {
		terrain = null;
	}
	
	@Test (expected = PreCondException.class)
	public void testPreInitFalse_1(){
		terrain.init(1, 3);
	}
	@Test (expected = PreCondException.class)
	public void testPreInitFalse_2(){
		terrain.init(3, 1);
	}
	@Test (expected = PreCondException.class)
	public void testPreInitFalse_3(){
		terrain.init(1, 1);
	}
	@Test
	public void testPreInitTrue_1(){
		try{
			terrain.init(2, 2);
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	@Test
	public void testPostInit_1(){
		terrain.init(5, 5);
		
		BlocService blocTest = new Bloc();
		blocTest.init(Type.Hero);
		
		assertTrue(terrain.getBloc(1,1).equals(blocTest));
		
		blocTest.init(Type.Vide);
		for(int x=1; x<=terrain.getSizeX(); x++){
			for(int y=1; y<=terrain.getSizeY(); y++){
				if(x==1 && y==1) break;
				assertTrue( terrain.getBloc(x,y).equals(blocTest));
			}
		}
		
		for(int x=1; x<=terrain.getSizeX(); x++){
			for(int y=1; y<=terrain.getSizeY(); y++){
				assertTrue(terrain.isChanged(x,y)==false);
			}
		}
		
		assertTrue(terrain.getXJoueur()==1);
		assertTrue(terrain.getYJoueur()==1);
		assertTrue(terrain.getNbJoueur()==1);
		assertTrue(terrain.getNbDiamant()==0);
		assertTrue(terrain.getNbPorte()==0);
		assertTrue(terrain.getSizeX()==5);
		assertTrue(terrain.getSizeY()==5);
		assertTrue(terrain.isStarted()==false);
	}
	
	@Test 
	public void testPreCloneTrue_1(){
		TerrainService cloneT = new Terrain();
		cloneT.init(3, 3);
		
		try{
			terrain.clone(cloneT);
		}catch(PreCondException e){
			assertTrue(false); return;
		}
		assertTrue(true);
	}
	@Test
	public void testPostClone_1(){
		TerrainService cloneT = new Terrain();
		cloneT.init(3, 3);
		
		terrain.clone(cloneT);
		
		assertTrue(terrain.getXJoueur()==cloneT.getXJoueur());
		assertTrue(terrain.getYJoueur()==cloneT.getYJoueur());
		assertTrue(terrain.getNbJoueur()==cloneT.getNbJoueur());
		assertTrue(terrain.getNbDiamant()==cloneT.getNbDiamant());
		assertTrue(terrain.getNbPorte()==cloneT.getNbPorte());
		assertTrue(terrain.getSizeX()==cloneT.getSizeX());
		assertTrue(terrain.getSizeY()==cloneT.getSizeY());
		assertTrue(terrain.isStarted()==cloneT.isStarted());
		
		for(int x=1; x<=terrain.getSizeX(); x++){
			for(int y=1; y<=terrain.getSizeY(); y++){
				assertTrue(terrain.getBloc(x,y).equals(cloneT.getBloc(x, y)));
			}
		}
		
		for(int x=1; x<=terrain.getSizeX(); x++){
			for(int y=1; y<=terrain.getSizeY(); y++){
				assertTrue(terrain.isChanged(x,y)==cloneT.isChanged(x, y));
			}
		}
	}
	
	@Test (expected = PreCondException.class)
	public void testPreStartTerrainFalse_1(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		
		terrain.startTerrain();
	}
	@Test (expected = PreCondException.class)
	public void testPreStartTerrainFalse_2(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		
		terrain.startTerrain();
	}
	@Test (expected = PreCondException.class)
	public void testPreStartTerrainFalse_3(){
		terrain.init(3,3);
		terrain.addObject(1, 3, Type.SortieFermee);
		
		terrain.startTerrain();
	}
	@Test
	public void testPreStartTerrainTrue_1(){
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		
		try{
			terrain.startTerrain();
		}catch (Exception e) {
			assertTrue(false); return;
		}
		assertTrue(true);
	}
	@Test
	public void testPostStartTerrain_1(){
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		terrain.startTerrain();
		
		assertTrue(terrain.getXJoueur()==terrainAtPre.getXJoueur());
		assertTrue(terrain.getYJoueur()==terrainAtPre.getYJoueur());
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant());
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte());
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.isStarted());
		
		for(int i=1; i<=terrainAtPre.getSizeX(); i++){
			for(int j=1; j<=terrainAtPre.getSizeY(); j++){
				assertTrue(terrain.isChanged(i, j)==terrainAtPre.isChanged(i, j));
			}
		}

		for(int i=1; i<=terrainAtPre.getSizeX(); i++){
			for(int j=1; j<=terrainAtPre.getSizeY(); j++){
				assertTrue(terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
			}
		}
	}
	
	@Test (expected = PreCondException.class)
	public void testPreAddObjectFalse_1(){
		// Conditions Initiales
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.SortieFermee);
		terrain.addObject(2, 2, Type.Diamant);
		terrain.startTerrain();
		
		terrain.addObject(0, 1, Type.Mur);
	}
	@Test (expected = PreCondException.class)
	public void testPreAddObjectFalse_2(){
		// Conditions Initiales
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.SortieFermee);
		terrain.addObject(2, 2, Type.Diamant);
		terrain.startTerrain();
		
		terrain.addObject(1, 0, Type.Mur);
	}
	@Test (expected = PreCondException.class)
	public void testPreAddObjectFalse_3(){
		// Conditions Initiales
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.SortieFermee);
		terrain.addObject(2, 2, Type.Diamant);
		terrain.startTerrain();
		
		terrain.addObject(-5, 0, Type.Mur);
	}
	@Test (expected = PreCondException.class)
	public void testPreAddObjectFalse_4(){
		terrain.init(3, 3);
		
		terrain.addObject(2, 1, Type.Hero);		
	}
	@Test (expected = PreCondException.class)
	public void testPreAddObjectFalse_5(){
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.SortieFermee);
		
		terrain.addObject(1, 2, Type.Mur);
	}
	@Test (expected = PreCondException.class)
	public void testPreAddObjectFalse_6(){
		terrain.init(3, 3);
		
		terrain.addObject(terrain.getSizeX()+1, 2, Type.Mur);
	}
	@Test (expected = PreCondException.class)
	public void testPreAddObjectFalse_7(){
		terrain.init(3, 3);
		
		terrain.addObject(2, terrain.getSizeY()+1, Type.Mur);
	}
	@Test
	public void testPreAddObjectTrue_1(){
		terrain.init(3, 3);
		
		try{
			terrain.addObject(2, 2, Type.Diamant);
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	@Test
	public void testPostAddObject_1(){
		terrain.init(3, 3);
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		terrain.addObject(2, 2, Type.Diamant);
		
		assertTrue(terrain.getXJoueur()==terrainAtPre.getXJoueur());
		assertTrue(terrain.getYJoueur()==terrainAtPre.getYJoueur());
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.isStarted()==terrainAtPre.isStarted());
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant()+1);	
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte());
		
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.isChanged(i, j)==terrainAtPre.isChanged(i, j));

		terrainAtPre.getBloc(2, 2).ChangeType(Type.Diamant);
		for(int i=1; i<=terrain.getSizeX(); i++){
			for(int j=1; j<=terrain.getSizeY(); j++){
				assertTrue(terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
			}
		}
	}
	@Test
	public void testPostAddObject_2(){
		terrain.init(3, 3);
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		terrain.addObject(2, 2, Type.SortieFermee);
		
		assertTrue(terrain.getXJoueur()==terrainAtPre.getXJoueur());
		assertTrue(terrain.getYJoueur()==terrainAtPre.getYJoueur());
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.isStarted()==terrainAtPre.isStarted());
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant());
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte()+1);
		
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.isChanged(i, j)==terrainAtPre.isChanged(i, j));

		terrainAtPre.getBloc(2, 2).ChangeType(Type.SortieFermee);
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
	}
	
	@Test (expected = PreCondException.class)
	public void testPreOpenDoorFalse_1(){
		terrain.init(3,3);
		
		terrain.openDoor();
	}
	@Test (expected = PreCondException.class)
	public void testPreOpenDoorFalse_2(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		
		terrain.openDoor();
	}
	@Test 
	public void testPreOpenDoorTrue_1(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		terrain.putHero(1, 2);
		
		try{
			terrain.openDoor();
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	@Test
	public void testPostOpenDoor_1(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		terrain.putHero(1, 2);
		
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		terrain.openDoor();
		
		assertTrue(terrain.getXJoueur()==terrainAtPre.getXJoueur());
		assertTrue(terrain.getYJoueur()==terrainAtPre.getYJoueur());
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant());
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte());
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.isStarted()==terrainAtPre.isStarted());
		
		for(int i=1; i<=terrain.getSizeX(); i++){
			for(int j=1; j<=terrain.getSizeY(); j++){
				assertTrue(terrain.isChanged(i, j)==terrainAtPre.isChanged(i, j));
			}
		}
		
		terrainAtPre.getBloc(1, 3).ChangeType(Type.SortieOuverte);
		for(int i=1; i<=terrain.getSizeX(); i++){
			for(int j=1; j<=terrain.getSizeY(); j++){
				assertTrue(terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
			}
		}
	}

	@Test (expected = PreCondException.class)
	public void testPreValidateFalse_1(){
		terrain.init(3, 3);
		
		terrain.validate();
	}
	@Test 
	public void testPreValidateTrue_1(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		
		try{
			terrain.validate();
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	@Test
	public void testPostValidate_1(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		terrain.validate();
		
		assertTrue(terrain.getXJoueur()==terrainAtPre.getXJoueur());
		assertTrue(terrain.getYJoueur()==terrainAtPre.getYJoueur());
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant());
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte());
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.isStarted()==terrainAtPre.isStarted());
		
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.isChanged(i, j)==false);
		
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue( terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
	}

	@Test (expected = PreCondException.class)
	public void testPreMoveObjectFalse_1(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		
		terrain.moveObject(1, 3, 2, 3);
	}
	@Test (expected = PreCondException.class)
	public void testPreMoveObjectFalse_2(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();

		terrain.moveObject(1, 2, 1, 3);
	}
	@Test (expected = PreCondException.class)
	public void testPreMoveObjectFalse_3(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		terrain.moveObject(1, 2, 2, 3);
		
		terrain.moveObject(2, 3, 3, 3);
	}
	@Test (expected = PreCondException.class)
	public void testPreMoveObjectFalse_4(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		
		terrain.moveObject(1, 2, 3, 3);
	}
	@Test
	public void testPreMoveObjectTrue_1(){
		terrain.init(3,3);
		terrain.addObject(2, 3, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		
		try{
			terrain.moveObject(2, 3, 3, 3);
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	@Test
	public void testPostMoveObject_1(){
		terrain.init(3,3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(1, 3, Type.SortieFermee);
		terrain.startTerrain();
		
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		Type typeAtPre = terrain.getTypeBloc(1,2);
		
		terrain.moveObject(1, 2, 3, 3);
		
		assertTrue(terrain.getXJoueur()==terrainAtPre.getXJoueur());
		assertTrue(terrain.getYJoueur()==terrainAtPre.getYJoueur());
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant());
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte());
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.isChanged(3, 3));
		assertTrue(terrain.isStarted()==terrainAtPre.isStarted());
		
		BlocService blocNew = terrain.getBloc(3, 3);
		BlocService bloc = terrain.getBloc(1, 2);

		for(int i=1; i<=terrain.getSizeX(); i++){
			for(int j=1; j<=terrain.getSizeY(); j++){
				if(terrain.getBloc(i,j)!=blocNew)
					assertTrue(terrain.isChanged(i, j)==terrainAtPre.isChanged(i,j));
				else
					assertTrue(terrain.isChanged(i, j));
			}
		}
		
		for(int i=1; i<=terrain.getSizeX(); i++){
			for(int j=1; j<=terrain.getSizeY(); j++){
				if(terrain.getBloc(i,j)==bloc){
					terrainAtPre.getBloc(i, j).ChangeType(Type.Vide);
				}
				else if(terrain.getBloc(i,j)==blocNew){
					terrainAtPre.getBloc(i, j).ChangeType(typeAtPre);
				}
				assertTrue(terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
			}
		}
	}

	@Test (expected = PreCondException.class)
	public void testPrePutHeroFalse_1(){
		terrain.init(3, 3);
		
		terrain.putHero(-1, 1);
	}
	@Test (expected = PreCondException.class)
	public void testPrePutHeroFalse_2(){
		terrain.init(3, 3);
		
		terrain.putHero(terrain.getSizeX()+2, 1);
	}
	@Test (expected = PreCondException.class)
	public void testPrePutHeroFalse_3(){
		terrain.init(3, 3);
		
		terrain.putHero(1, terrain.getSizeY()+2);
	}
	@Test (expected = PreCondException.class)
	public void testPrePutHeroFalse_4(){
		terrain.init(3, 3);
		
		terrain.putHero(1, -1);
	}
	@Test (expected = PreCondException.class)
	public void testPrePutHeroFalse_5(){
		terrain.init(3, 3);
		
		terrain.putHero(-5, -1);
	}
	@Test
	public void testPrePutHeroTrue_1(){
		terrain.init(3, 3);
			
		try{
			terrain.putHero(0, 0);
		}catch (Exception e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	@Test
	public void testPrePutHeroTrue_2(){
		terrain.init(3, 3);
			
		try{
			terrain.putHero(terrain.getSizeX()+1, 3);
		}catch (Exception e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	// TODO beaucoup de modifs ici :
	@Test
	public void testPostPutHero_1(){
		terrain.init(3, 3);
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		terrain.putHero(0, 0);
		
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte());
		assertTrue(terrain.isStarted()==terrainAtPre.isStarted());
		assertTrue(terrain.getXJoueur()==terrain.getSizeX());
		assertTrue(terrain.getYJoueur()==terrain.getSizeY());
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant());
		
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.isChanged(i, j)==terrainAtPre.isChanged(i, j));
		
		terrainAtPre.getBloc(0, 0).ChangeType(Type.Hero);
		terrainAtPre.getBloc(terrainAtPre.getXJoueur(), terrainAtPre.getYJoueur()).ChangeType(Type.Vide);
		for(int i=1; i<=terrain.getSizeX(); i++){
			for(int j=1; j<=terrain.getSizeY(); j++){
				assertTrue(terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
			}
		}
	}
	@Test
	public void testPostPutHero_2(){
		terrain.init(3, 3);
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		terrain.putHero(terrain.getSizeX()+1, terrain.getSizeY()+1);
		
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte());
		assertTrue(terrain.isStarted()==terrainAtPre.isStarted());
		assertTrue(terrain.getXJoueur()==1);
		assertTrue(terrain.getYJoueur()==1);
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant());
		
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.isChanged(i, j)==terrainAtPre.isChanged(i, j));
		

		terrainAtPre.getBloc(terrainAtPre.getXJoueur(), terrainAtPre.getYJoueur()).ChangeType(Type.Vide);
		terrainAtPre.getBloc(terrain.getSizeX()+1, terrain.getSizeY()+1).ChangeType(Type.Hero);

		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
	}	
	@Test
	public void testPostPutHero_3(){
		terrain.init(3, 3);
		terrain.addObject(3, 2, Type.Diamant);
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		terrain.putHero(3, 2);
		
		assertTrue(terrain.getNbJoueur()==terrainAtPre.getNbJoueur());
		assertTrue(terrain.getNbPorte()==terrainAtPre.getNbPorte());
		assertTrue(terrain.isStarted()==terrainAtPre.isStarted());
		assertTrue(terrain.getXJoueur()==3);
		assertTrue(terrain.getYJoueur()==2);
		assertTrue(terrain.getNbDiamant()==terrainAtPre.getNbDiamant()-1);
		
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.isChanged(i, j)==terrainAtPre.isChanged(i, j));
		
		
		terrainAtPre.getBloc(3, 2).ChangeType(Type.Hero);
		terrainAtPre.getBloc(terrainAtPre.getXJoueur(), terrainAtPre.getYJoueur()).ChangeType(Type.Vide);
		for(int i=1; i<=terrain.getSizeX(); i++)
			for(int j=1; j<=terrain.getSizeY(); j++)
				assertTrue(terrain.getBloc(i,j).equals(terrainAtPre.getBloc(i, j)));
	}

	
	@Test
	public void testInvariant1_1(){
		terrain.init(4,4);
		
		assertTrue(terrain.getNbJoueur()==1);
		assertTrue(terrain.getXJoueur()<=terrain.getSizeX() && 1<=terrain.getXJoueur());
		assertTrue(terrain.getYJoueur()<=terrain.getSizeY() && 1<=terrain.getYJoueur());
		assertTrue(terrain.getNbPorte()==1 || !terrain.isStarted());
		assertTrue(terrain.getNbDiamant()>=0);
	}
	@Test
	public void testInvariant1_2(){
		TerrainService terrainC = new Terrain();
		terrainC.init(4,4);
		terrain.clone(terrainC);
		
		assertTrue(terrain.getNbJoueur()==1);
		assertTrue(terrain.getXJoueur()<=terrain.getSizeX() && 1<=terrain.getXJoueur());
		assertTrue(terrain.getYJoueur()<=terrain.getSizeY() && 1<=terrain.getYJoueur());
		assertTrue(terrain.getNbPorte()==1 || !terrain.isStarted());
		assertTrue(terrain.getNbDiamant()>=0);
	}
	@Test
	public void testInvariant1_3(){
		terrain.init(4,4);
		terrain.addObject(2, 2, Type.Diamant);
		
		assertTrue(terrain.getNbJoueur()==1);
		assertTrue(terrain.getXJoueur()<=terrain.getSizeX() && 1<=terrain.getXJoueur());
		assertTrue(terrain.getYJoueur()<=terrain.getSizeY() && 1<=terrain.getYJoueur());
		assertTrue(terrain.getNbPorte()==1 || !terrain.isStarted());
		assertTrue(terrain.getNbDiamant()>=0);
	}
	@Test
	public void testInvariant1_4(){
		terrain.init(4,4);
		terrain.addObject(2, 2, Type.Diamant);
		terrain.addObject(2, 3, Type.SortieFermee);
		terrain.startTerrain();
		
		assertTrue(terrain.getNbJoueur()==1);
		assertTrue(terrain.getXJoueur()<=terrain.getSizeX() && 1<=terrain.getXJoueur());
		assertTrue(terrain.getYJoueur()<=terrain.getSizeY() && 1<=terrain.getYJoueur());
		assertTrue(terrain.getNbPorte()==1 || !terrain.isStarted());
		assertTrue(terrain.getNbDiamant()>=0);
	}
	@Test
	public void testInvariant1_5(){
		terrain.init(4,4);
		terrain.addObject(2, 2, Type.Diamant);
		terrain.addObject(2, 3, Type.SortieFermee);
		terrain.startTerrain();
		terrain.putHero(2, 2);
		
		assertTrue(terrain.getNbJoueur()==1);
		assertTrue(terrain.getXJoueur()<=terrain.getSizeX() && 1<=terrain.getXJoueur());
		assertTrue(terrain.getYJoueur()<=terrain.getSizeY() && 1<=terrain.getYJoueur());
		assertTrue(terrain.getNbPorte()==1 || !terrain.isStarted());
		assertTrue(terrain.getNbDiamant()>=0);
	}
	@Test
	public void testInvariant1_6(){
		terrain.init(4,4);
		terrain.addObject(2, 2, Type.Diamant);
		terrain.addObject(2, 3, Type.SortieFermee);
		terrain.startTerrain();
		terrain.validate();
		
		assertTrue(terrain.getNbJoueur()==1);
		assertTrue(terrain.getXJoueur()<=terrain.getSizeX() && 1<=terrain.getXJoueur());
		assertTrue(terrain.getYJoueur()<=terrain.getSizeY() && 1<=terrain.getYJoueur());
		assertTrue(terrain.getNbPorte()==1 || !terrain.isStarted());
		assertTrue(terrain.getNbDiamant()>=0);
	}
	@Test
	public void testInvariant1_7(){
		terrain.init(4,4);
		terrain.addObject(2, 2, Type.Diamant);
		terrain.addObject(2, 3, Type.SortieFermee);
		terrain.startTerrain();
		terrain.moveObject(2, 2, 2, 1);
		
		assertTrue(terrain.getNbJoueur()==1);
		assertTrue(terrain.getXJoueur()<=terrain.getSizeX() && 1<=terrain.getXJoueur());
		assertTrue(terrain.getYJoueur()<=terrain.getSizeY() && 1<=terrain.getYJoueur());
		assertTrue(terrain.getNbPorte()==1 || !terrain.isStarted());
		assertTrue(terrain.getNbDiamant()>=0);
	}
	
}
